package com.example.java.newFeature.thread;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

// CompletableFuture：一种可组合的异步编程机制，用于处理异步操作和并发编程
// 每一个 CompletableFuture 整体上都代表一个异步操作，但其内部可以有0个或多个依赖任务，
// 他们可以通过 thenApply、thenAccept、thenRun 等方法来设置依赖关系。这些依赖任务是串行的
public class CompletableFutureDemo {
    // 自定义执行器，用于执行异步任务
    private static final Executor customExecutor = Executors.newFixedThreadPool(3);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 模拟异步任务：验证库存
        CompletableFuture<Boolean> checkStockFuture = CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟库存检查耗时
                Thread.sleep(1000);
                System.out.println("Checking stock...");
                // 假设库存充足
                return true;
            } catch (InterruptedException e) {
                e.printStackTrace();
                return false;
            }
        });

        // 模拟异步任务：验证支付
        CompletableFuture<Boolean> checkPaymentFuture = CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟支付验证耗时
                Thread.sleep(1500);
                System.out.println("Checking payment...");
                // 假设支付有效
                return true;
            } catch (InterruptedException e) {
                e.printStackTrace();
                return false;
            }
        });

        // 异步任务组合：使用 thenCombine 方法将两个异步任务组合起来。两个任务的执行顺序是异步的，但组合操作是同步的。
        // 两个异步任务的结果会作为参数传递给 thenCombine 方法的第二个参数，并返回一个新的 CompletableFuture
        // 结果处理：将两个异步任务的结果组合起来
        // 当库存和支付都验证通过后，执行准备发货流程
        CompletableFuture<Void> prepareShipmentFuture = checkStockFuture.thenCombine(checkPaymentFuture, (stockValid, paymentValid) -> {
            if (stockValid && paymentValid) {
                System.out.println("Preparing shipment...");
                // 模拟发货准备耗时
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Shipment prepared!");
            } else {
                System.out.println("Failed to prepare shipment due to invalid stock or payment.");
            }
            return null; // Void类型返回null
        });

        // 等待所有异步任务完成
        prepareShipmentFuture.get(); // 这会阻塞主线程直到 prepareShipmentFuture 完成

        System.out.println("Order processing complete.");


        System.out.println("-----------------------------------");
        // thenApplyAsync：异步执行任务，并返回结果
        checkPaymentFuture.thenApplyAsync(paymentValid -> {
            if (paymentValid) {
                System.out.println("Payment is valid.");
            } else {
                System.out.println("Payment is invalid.");
            }
            return null;
        });
    }
}
